// AI服务封装
class AIService {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.baseUrl = 'https://open.bigmodel.cn/api/paas/v4/chat/completions';
        this.abortController = null;
    }

    // 第一步：分析表结构并推断字段类型
    async analyzeFieldTypes(sql) {
        return await this._callAI([
            {
                role: "system",
                content: `你是一个数据库专家，负责分析表结构中的字段类型。请严格按照以下格式返回分析结果：

1. 只返回JSON格式数据
2. 不要添加任何其他内容
3. 不要使用markdown代码块
4. 不要添加任何说明文字

分析要求：
- 对每个字段，只返回一个type属性
- type必须使用中文描述字段类型，如：用户ID、姓名、手机号、邮箱地址、身份证号、年龄、性别、日期时间、金额等

返回格式必须严格遵循：
{
    "字段名": {
        "type": "中文数据类型"
    }
}

重要提醒：
- 只输出JSON对象
- 每个字段只包含type属性
- 不要包含任何其他属性
- 不要使用markdown格式
- 不要添加任何说明文字`
            },
            {
                role: "user",
                content: `仅返回以下建表语句中字段的JSON分析结果：\n${sql}`
            }
        ]);
    }

    // 第二步：根据确定的字段类型生成测试数据模板
    async generateTestSQL(tableName, fields, rowCount = 10, onStatusChange = null) {
        try {
            // 通知开始生成数据
            onStatusChange?.('正在生成测试数据...');

            // 获取多行数据
            const template = await this._callAI([
                {
                    role: "system",
                    content: `你是一个SQL测试数据生成专家。请严格按照以下要求生成数据：

1. 返回多行数据，每行数据用换行符分隔
2. 每行数据的值用逗号分隔
3. 每个值都要根据字段类型生成合适且不同的值
4. 不要包含字段名
5. 不要包含任何SQL关键字
6. 不要使用markdown代码块
7. 不要添加任何说明文字

数据类型说明：
- 用户ID：使用6-10位数字，每条数据都不同
- 用户名：使用5-10位字母数字组合，每条数据都不同
- 密码哈希：使用32位字母数字组合，每条数据都不同
- 邮箱：使用userXXX@example.com格式，XXX为不同数字
- 手机号：使用138XXXXXXXX格式，后8位不同
- URL：使用example.com/xxx格式，xxx部分不同
- 性别：使用0/1/2表示
- 日期：使用YYYY-MM-DD格式，日期随机不同
- 日期时间：使用YYYY-MM-DD HH:mm:ss格式，时间随机不同
- 金额：使用100.00格式，金额随机不同
- 布尔值：使用true/false表示

返回格式：
值1,值2,值3,值4
值1,值2,值3,值4
值1,值2,值3,值4

重要提醒：
- 返回指定数量的数据行
- 每行数据用换行符分隔
- 每行中的值用逗号分隔
- 字符串类型无需加引号
- 不要包含括号
- 不要包含任何其他字符
- 不要使用markdown格式
- 不要添加任何说明文字
- 确保每行数据都不完全相同`
                },
                {
                    role: "user",
                    content: `请生成 ${rowCount} 行不同的测试数据（每行用换行符分隔，行内值用逗号分隔）：\n${JSON.stringify(fields, null, 2)}`
                }
            ]);

            // 处理模板，将其转换为数组
            const rows = template.trim().split('\n');
            const sqlStatements = [];
            const fieldNames = fields.map(f => f.name);

            for (let i = 0; i < rows.length; i++) {
                // 处理每一行数据
                const values = rows[i].trim().split(',').map(v => v.trim());
                
                // 处理每个值，添加适当的引号
                const processedValues = values.map(value => {
                    if (value === 'true' || value === 'false' || /^\d+$/.test(value) || /^\d+\.\d+$/.test(value)) {
                        return value;
                    }
                    return `'${value}'`;
                });

                // 生成完整的INSERT语句
                const sql = `INSERT INTO ${tableName} (${fieldNames.join(', ')}) VALUES (${processedValues.join(', ')});`;
                sqlStatements.push(sql);

                // 每处理5条数据更新一次状态
                if ((i + 1) % 5 === 0) {
                    onStatusChange?.(`已处理 ${i + 1} 条数据...`);
                }
            }

            // 通知完成
            onStatusChange?.('完成');

            // 返回所有SQL语句
            return sqlStatements.join('\n');
        } catch (error) {
            // 通知错误
            onStatusChange?.('生成数据时发生错误');
            throw error;
        }
    }

    // 生成各种类型的数据
    _generateName() {
        const surnames = '张王李赵刘陈杨黄周吴';
        const names = '伟芳娜秀英俊杰明华';
        return `'${surnames[Math.floor(Math.random() * surnames.length)]}${names[Math.floor(Math.random() * names.length)]}'`;
    }

    _generatePhone() {
        return `'1${Math.floor(Math.random() * 10)}${Math.floor(Math.random() * 10)}${Array(8).fill(0).map(() => Math.floor(Math.random() * 10)).join('')}'`;
    }

    _generateEmail() {
        const domains = ['qq.com', '163.com', 'gmail.com', 'outlook.com'];
        return `'user${Math.floor(Math.random() * 10000)}@${domains[Math.floor(Math.random() * domains.length)]}'`;
    }

    _generateDateTime() {
        const date = new Date(Date.now() - Math.floor(Math.random() * 365 * 24 * 60 * 60 * 1000));
        return `'${date.toISOString().slice(0, 19).replace('T', ' ')}'`;
    }

    _generateDate() {
        const date = new Date(Date.now() - Math.floor(Math.random() * 365 * 24 * 60 * 60 * 1000));
        return `'${date.toISOString().slice(0, 10)}'`;
    }

    _generateAddress() {
        const provinces = ['北京市', '上海市', '广东省', '江苏省'];
        const cities = ['朝阳区', '浦东新区', '广州市', '南京市'];
        const streets = ['人民路', '中山路', '解放路', '建国路'];
        return `'${provinces[Math.floor(Math.random() * provinces.length)]}${cities[Math.floor(Math.random() * cities.length)]}${streets[Math.floor(Math.random() * streets.length)]}${Math.floor(Math.random() * 100)}号'`;
    }

    _generateCompany() {
        const prefixes = ['北京', '上海', '广州', '深圳'];
        const types = ['科技', '网络', '信息', '电子'];
        const suffixes = ['有限公司', '股份有限公司', '科技有限公司'];
        return `'${prefixes[Math.floor(Math.random() * prefixes.length)]}${types[Math.floor(Math.random() * types.length)]}${suffixes[Math.floor(Math.random() * suffixes.length)]}'`;
    }

    _generateText() {
        const words = ['测试', '数据', '示例', '文本', '内容'];
        return `'${words[Math.floor(Math.random() * words.length)]}${words[Math.floor(Math.random() * words.length)]}${words[Math.floor(Math.random() * words.length)]}'`;
    }

    _generateUrl() {
        const protocols = ['http', 'https'];
        const domains = ['example.com', 'test.com', 'demo.com'];
        const paths = ['index', 'home', 'about', 'contact'];
        return `'${protocols[Math.floor(Math.random() * protocols.length)]}://${domains[Math.floor(Math.random() * domains.length)]}/${paths[Math.floor(Math.random() * paths.length)]}'`;
    }

    _generateIP() {
        return `'${Array(4).fill(0).map(() => Math.floor(Math.random() * 256)).join('.')}'`;
    }

    _generateNumber(min, max) {
        return Math.floor(Math.random() * (max - min + 1)) + min;
    }

    /**
     * 调用AI服务
     * @private
     */
    async _callAI(messages, onStatusChange = null) {
        // 创建新的AbortController
        this.abortController = new AbortController();
        
        try {
            const response = await fetch(this.baseUrl, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${this.apiKey}`
                },
                body: JSON.stringify({
                    model: "glm-4",
                    messages: messages,
                    temperature: 0.7,
                    max_tokens: 2048,
                    stream: false
                }),
                signal: this.abortController.signal
            });

            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }

            const data = await response.json();
            if (!data.choices || !data.choices[0]?.message?.content) {
                throw new Error('AI响应格式错误');
            }

            const content = data.choices[0].message.content;
            
            // 对于generateTestSQL方法，过滤并返回内容
            if (messages[0].content.includes('SQL测试数据生成专家')) {
                // 移除所有注释和说明文字
                const lines = content.split('\n')
                    .map(line => line.trim())
                    .filter(line => {
                        // 过滤掉空行和注释性质的行
                        if (!line) return false;
                        if (line.startsWith('以下') || line.startsWith('请注意') || line.startsWith('这些数据')) return false;
                        if (line.includes('生成的') || line.includes('测试数据')) return false;
                        if (line.startsWith('-') || line.startsWith('*')) return false;
                        // 只保留包含数字或字母的行
                        return /[a-zA-Z0-9]/.test(line);
                    });
                return lines.join('\n');
            }

            // 处理可能包含的Markdown代码块和注释
            let jsonContent = content
                .replace(/```json\n|\n```/g, '')  // 移除Markdown代码块标记
                .replace(/\/\/.*$/gm, '')         // 移除单行注释
                .replace(/\/\*[\s\S]*?\*\//g, '') // 移除多行注释
                .trim();                          // 移除前后空白

            try {
                // 尝试直接解析清理后的内容
                return JSON.parse(jsonContent);
            } catch (e) {
                console.warn('直接解析失败，尝试修复JSON格式:', e);
                
                try {
                    // 预处理JSON字符串
                    jsonContent = jsonContent
                        // 修复URL字段
                        .replace(/"example":\s*"(http[s]?:\/\/[^"]*?)(?:\n|$)/g, '"example": "$1"}')
                        // 确保每个字段都有完整的结构
                        .replace(/("[^"]+"\s*:\s*{[^}]*?)(?=\s*")/g, '$1},')
                        // 修复多余的换行和空格
                        .replace(/\s+/g, ' ')
                        // 确保所有属性名都有引号
                        .replace(/([{,]\s*)(\w+):/g, '$1"$2":')
                        // 修复可能的尾随逗号
                        .replace(/,(\s*})/g, '$1')
                        // 修复可能缺失的大括号
                        .replace(/({[^}]*)"([^"]+)":\s*{([^}]*)}(?!\s*[,}])/g, '$1"$2": {$3}},');

                    // 确保JSON对象的完整性
                    if (!jsonContent.endsWith('}')) {
                        jsonContent += '}';
                    }
                    if (!jsonContent.startsWith('{')) {
                        jsonContent = '{' + jsonContent;
                    }

                    // 尝试解析修复后的JSON
                    const result = JSON.parse(jsonContent);
                    
                    // 验证结果的完整性
                    if (typeof result !== 'object' || result === null) {
                        throw new Error('解析结果不是有效的对象');
                    }

                    return result;
                } catch (e2) {
                    console.error('修复后仍然无法解析JSON:', e2);
                    console.error('问题内容:', jsonContent);
                    throw new Error('无法解析AI返回的JSON格式，请检查返回内容的完整性');
                }
            }
        } catch (error) {
            if (error.name === 'AbortError') {
                throw new Error('用户取消了操作');
            }
            console.error('AI服务调用失败:', error);
            throw new Error('AI服务调用失败: ' + error.message);
        }
    }

    // 取消当前的AI调用
    cancelCurrentCall() {
        if (this.abortController) {
            this.abortController.abort();
            this.abortController = null;
        }
    }
} 